home *** CD-ROM | disk | FTP | other *** search
/ The Arsenal Files 4 / The Arsenal Files 4 (Arsenal Computer).ISO / casm / au116-as.exe / UTIL / OKTOPROC.CPP < prev    next >
C/C++ Source or Header  |  1994-02-20  |  4KB  |  179 lines
  1. #include "..\au.hpp"
  2.  
  3. /*░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░*/
  4. char ok_to_process(AU *au, char *filename)
  5. {
  6.     LIST *el;
  7.  
  8.     for (el=au->dont_touch.head; el != NULL; el = el->next)
  9.     {
  10.         if (wildcard_compare(au, filename, el->data))
  11.             return FALSE;
  12.     }
  13.     return TRUE;
  14. }
  15. /*************************************************************************/
  16. static void get_range(AU *au, char *range, char *wildcard, int *range_size)
  17. {
  18.     int invert = FALSE;
  19.  
  20.     memset(range, FALSE, 256);
  21.     if (*wildcard == '[')
  22.     {
  23.         wildcard++;
  24.         *range_size = 1;
  25.         if (*wildcard == '^')
  26.         {
  27.             invert = TRUE;
  28.             wildcard++;
  29.             (*range_size)++;
  30.         }
  31.         while (*wildcard != ']')
  32.         {
  33.             if (*wildcard == '\0')
  34.             {
  35.                 au_printf_error(au, "\n] missing in file specification");
  36.                 exit(1);
  37.             }
  38.  
  39.             if (*(wildcard + 1) == '-')
  40.             {
  41.                 unsigned char first, last;
  42.                 first = *wildcard;
  43.                 last = *(wildcard+2);
  44.                 if (first > last)
  45.                 {
  46.                     unsigned char temp;
  47.                     temp = first;
  48.                     first = last;
  49.                     last = temp;
  50.                 }
  51.                 memset(range+first, TRUE, last-first+1);
  52.                 wildcard+=3;
  53.                 (*range_size)+=3;
  54.             }
  55.             else
  56.             {
  57.                 range[*wildcard] = TRUE;
  58.                 wildcard++;
  59.                 (*range_size)++;
  60.             }
  61.         }
  62.         (*range_size)++;
  63.  
  64.         if (invert)
  65.         {
  66.             for (int i=0; i<256; i++)
  67.             {
  68.                 if (range[i])
  69.                     range[i] = FALSE;
  70.                 else
  71.                     range[i] = TRUE;
  72.             }
  73.         }
  74.     }
  75.     else
  76.     {
  77.         range[*wildcard] = TRUE;
  78.         *range_size = 1;
  79.     }
  80.     return;
  81. }
  82. /*************************************************************************/
  83. char wildcard_compare(AU *au, char *filename, char *wildcard)
  84. {
  85.     unsigned char Wchar, Fchar, Nchar;
  86.     int  Wpos = 0, Fpos =0;
  87.     int  range_size;        /* ie [a-b] is 5 */
  88.     int  try_again_Wpos=-1;
  89.     int  try_again_Fpos=-1;
  90.     char range[256];
  91.  
  92.     if (strcmp(wildcard, "$.*") == 0)
  93.     {
  94.         return
  95.            (wildcard_compare(au, filename, "*.SU[0-9]") ||
  96.             wildcard_compare(au, filename, "*.MO[0-9]") ||
  97.             wildcard_compare(au, filename, "*.TU[0-9]") ||
  98.             wildcard_compare(au, filename, "*.WE[0-9]") ||
  99.             wildcard_compare(au, filename, "*.TH[0-9]") ||
  100.             wildcard_compare(au, filename, "*.FR[0-9]") ||
  101.             wildcard_compare(au, filename, "*.SA[0-9]"));
  102.     }
  103.  
  104.     strupr(wildcard);
  105.     strupr(filename);
  106.  
  107.     for(EVER)
  108.     {
  109.         Wchar = wildcard[Wpos];
  110.         Fchar = filename[Fpos];
  111.         if (Fchar == '\0' && Wchar == '\0')
  112.             return TRUE;
  113.  
  114.         switch (Wchar)
  115.         {
  116.         case '*':
  117.             /* Take care of ** and *? combinations */
  118.             for(EVER)
  119.             {
  120.                 Nchar = wildcard[Wpos+1];
  121.                 if (Nchar != '*' && Nchar != '?')
  122.                     break;
  123.                 Wpos++;
  124.             }
  125.             get_range(au, range, wildcard+Wpos+1, &range_size);
  126.  
  127.             for(EVER)
  128.             {
  129.                 Fchar = filename[Fpos];
  130.                 if (range[Fchar])
  131.                 {
  132.                     try_again_Fpos = Fpos+1;
  133.                     try_again_Wpos = Wpos;
  134.                     Wpos++;
  135.                     break;
  136.                 }
  137.                 if (Fchar == '\0')
  138.                     return FALSE;
  139.                 Fpos++;
  140.             }
  141.             break;
  142.         case '?':
  143.             if (Fchar == '\0')
  144.                 return FALSE;
  145.             Wpos++;
  146.             Fpos++;
  147.             break;
  148.         default:
  149.             get_range(au, range, wildcard+Wpos, &range_size);
  150.             if (!range[Fchar])
  151.             {
  152.                 if (try_again_Fpos != -1)
  153.                 {
  154.                     Fpos = try_again_Fpos;
  155.                     Wpos = try_again_Wpos;
  156.                     continue;
  157.                 }
  158.                 return FALSE;
  159.             }
  160.             Wpos += range_size;
  161.             Fpos++;
  162.         }
  163.     }
  164. }
  165. #if 0
  166. /*************************************************************************/
  167. BYTE wildcard_compare_multi(LISTPTR *listPtr, char *wildcard)
  168. {
  169.     LIST *el;
  170.  
  171.     for (el = listPtr->head; el != NULL; el = el->next)
  172.     {
  173.         if (wildcard_compare(el->data, wildcard))
  174.             return TRUE;
  175.     }
  176.     return FALSE;
  177. }
  178. #endif
  179.